package cn.tedu.justone.pack02;

/**
 * ZZ：JustOne
 * VX：Andylau2020smile
 * DY：JustOne2018
 * ZT：《线程的生命状态》
 */
public class Demo58_线程的生命状态 {

    //程序员常规分类的五大状态：
    // 1,新建状态：New ------- 线程对象创建了但还没有调用start()方法
    // 2,就绪状态：Runnalbe -- 调用了start()方法但还没有得到时间片
    // 3,运行状态：Running --- 得到了时间片，正在运行中
    // 4,阻塞状态：Blocked --- 遇到了各种阻塞
    // 5,死亡状态：Dead ------ 任务执行完毕线程被销毁

    //分别解说：
    // 1,新建状态：New
    //   何时开始：当my线程对象创建了但还没有调用my.start()方法
    //   何时结束：当我们调用了my.start()时会转入Runnable状态

    // 2,就绪状态：Runnalbe
    //   何时开始：当my.start()被调用但还没有得到时间片时
    //           当my面对的各种阻塞被清除时
    //   何时结束：当my得到时间片时会转入Running状态

    // 3,运行状态：Running
    //   何时开始：当处于Runnable状态的线程得到时间片时
    //   何时结束：当my失去时间片时会转入Runnable状态
    //           当my遇到各种阻塞时会转入对应的Blocked状态
    //           当my运行结速时会转入Dead状态

    // 4,阻塞状态 Blocked
    //   何时开始：当my线程执行了lock.wait()后就开始了 等待阻塞
    //   何时结束：当程序执行了lock.notify()后会转入 synchronized锁的同步阻塞
    //
    //   何时开始：当my线程遇到了t.join()时后就开始了 等待阻塞
    //   何时结束：当t线程执行完后my就会转成 Runnable状态
    //
    //   何时开始：当my线程执行了Thread.sleep(long m)后就开始了 休眠阻塞
    //   何时结束：当sleep(long m)时间结束后会转为 Runnable状态
    //
    //   何时开始：当my线程面临着synchronized锁时就开始了 同步阻塞
    //   何时结束：当my线程面临的synchronized锁被释放时，会转为 Runnable状态
    //
    //   何时开始：当my线程遇到了IO请求时就开始了 IO阻塞
    //   何时结束：当my线程遇到了IO结束后会转为 Runnable状态

    // 5,死亡状态 Dead
    //   何时开始：当my线程任务执行完毕后被销毁就进入了Dead状态
    //   何时结束：Game Over

    //------------------------------------------------------------------------

    //Java源码中的六大状态：
    // 1,Thread.State.NEW-------------新建状态 (线程对象创建了但还没有调用start()方法)
    // 2,Thread.State.RUNNABLE;-------运行状态 (ready:就绪, running:运行)
    // 3,Thread.State.BLOCKED;--------阻塞状态 (等待同步锁释放)
    // 4,Thread.State.WAITING;--------等待状态 (等待另一个线程执行特定的动作且无计时)
    // 5,Thread.State.TIMED_WAITING;--计时等待 (等待另一个线程执行特定的动作且有计时)
    // 6,Thread.State.TERMINATED;-----终止状态 (该线程的任务执行完了)


    //分别解说：
    //1,Thread.State.NEW;新建状态
    //  何时开始：当my线程对象创建了但还没有调用my.start()方法时处于NEW状态。
    //  何时结束：当我们调用了my.start()时，会转入RUNNABLE状态

    //2,Thread.State.RUNNABLE;运行状态
    //  何时开始：当我们调用了my.start()方法时，当my面对的各种阻塞被清除时
    //  何时结束：当my遇到各种阻塞时会转入对应的阻塞状态，当my运行结速时会转入 TERMINATED状态
    //  特别说明：RUNNABLE只是表示JVM正在运行my线程，但my线程本身会有两种情况：
    //           a,得到了时间片，即是正在运行，处于Running(运行中)
    //           b,失去了时间片，即没有在运行，处于Ready(就绪)

    //3,Thread.State.BLOCKED;阻塞状态
    //  何时开始：当my线程面临着synchronized锁时
    //  何时结束：当my线程面临的synchronized锁被释放时，会转为 RUNNABLE状态

    //4,Thread.State.WAITING;等待状态
    //  何时开始：当执行了lock.wait() 或 t.join() 或 xx.park()等方法时
    //  何时结束：当执行了lock.notify() 或 xx.unpark() 或 t线程执行完毕时，会转为 BLOCKED状态

    //5,Thread.State.TIMED_WAITING;计时等待
    //  何时开始：当执行了lock.wait(long m), my.sleep(long m), t.join(long m)等方法时
    //  何时结束：当执行了lock.notify(); 或 等待时间到，会转为 RUNNABLE状态

    //6,Thread.State.TERMINATED;终止状态
    //  何时开始：当线程的任务执行完毕时
    //  何时结束：游戏结束，不可更改




    //---------------------
    //什么是阻塞式IO/非阻塞式IO，什么又是同步IO/异步IO呢?
    //① 等到需要的数据都准备完毕再回复 ———— 中间一直默不作声，这就是同步IO。
    //② 先告诉应用程序数据没有准备好，然后准备好数据，通知（回调）应用程序或被轮询 ——这就是异步IO。
    //① 一直等，直接数据都发过来，然后再进行下一步。————   阻塞IO。
    //② 先干别的，然后定期查询或等待回调。————— 非阻塞IO。

    //-----------------------------------
    //《阿里面试失败后，一气之下我图解了Java中18把锁》
    //https://blog.csdn.net/guoguo527/article/details/118004077?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166078434816781647557323%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=166078434816781647557323&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~pc_rank_34-5-118004077-null-null.142^v41^pc_rank_34_1,185^v2^control&utm_term=synchronized%E9%94%81%E4%BB%A3%E7%A0%81%E5%9D%97%E6%AF%94%E9%94%81%E6%96%B9%E6%B3%95%E6%80%A7%E8%83%BD%E6%9B%B4%E5%A5%BD&spm=1018.2226.3001.4187


    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                sum();
                sum();
                sum();
            }
        };
        t1.setName("t1");

        Thread t2 = new Thread(){
            @Override
            public void run() {
                sum();
                try {
                    t1.wait(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                sum();

            }
        };
        t2.setName("t2");

        System.out.println("t2的状态是"+t2.getState());

        t2.start();
        //运行观察状态
        for (int i = 0; i < 30; i++) {
            System.out.println("t2的状态是"+t2.getState());
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    //为了让代码更优雅，编写统一的【5000W次的随机数相加】
    public static void sum(){
        int sum = 0;
        for (int i = 0; i < 50000000; i++) {
            int ran = (int)(Math.random()*10);
            sum += ran;
        }
        Thread t = Thread.currentThread();
        System.out.println(t.getName() + "求和结果："+sum);
    }


}
